package com.fit.utils.se;

import java.util.Collection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串工具
 * @author hcl
 *
 */
public class StringUtil {
	
	/**
	 * 操作字符串,在前面操作
	 */
	public static final String BEFORE = "before";
	
	/**
	 * 操作字符串,在后面操作
	 */
	public static final String AFTER = "after";
	
	
	private static final Pattern FIRST_LETTER_PATTERN = Pattern.compile("_[a-z]");
	
	/**
     * 去掉前后空格
     * @param str
     * @return
     * @author hcl
     */
    public static String trim(String str){
    	return null == str ? null : str.trim();
    }
	
	
	/**
	 * 判断此字符串是否是一个整数, 注意：1.0算是一个小数(包含了负数)
	 * @param str
	 * @return
	 * @author hcl
	 */
	public static boolean isInt(String str){
		return EmptyUtils.isEmpty(str) ? false : str.matches("^-?\\d+$");
	}
	
	/**
	 * 判断此字符串是否不是一个整数, 注意：1.0算是一个小数(包含了负数)
	 * @param str
	 * @return
	 * @author hcl
	 */
	public static boolean isNotInt(String str){
		return !StringUtil.isInt(str);
	}
	
	
	/**
	 * 判断此字符串是否是一个带小数的数字, 注意：1.0算是一个小数 (包含了负数)
	 * @param str
	 * @return
	 */
	public static boolean isDecimal(String str){
		return EmptyUtils.isEmpty(str) ? false : str.matches("^-?\\d+\\.\\d+$");
	}
	
	/**
	 * 判断此字符串是否不是一个带小数的数字, 注意：1.0算是一个小数 (包含了负数)
	 * @param str
	 * @return
	 */
	public static boolean isNotDecimal(String str){
		return !StringUtil.isDecimal(str);
	}
	
	/**
	 * 判断此字符串是否是小数或整数(包含了负数)
	 * @param str
	 * @return
	 */
	public static boolean isNum(String str){
		return EmptyUtils.isEmpty(str) ? false : str.matches("^-?\\d+(\\.\\d+)?$");
	}
	
	
	/**
	 * 判断此字符串是否不是小数或整数(包含了负数)
	 * @param str
	 * @return
	 */
	public static boolean isNotNum(String str){
		return !StringUtil.isNum(str);
	}
	
	
	/**
	 * 判断是否是一个boolean类型(是否只包含了true和false)
	 * @param str
	 * @return
	 */
	public static boolean isBoolean(String str){
		return EmptyUtils.isEmpty(str) ? false : str.matches("^true|false$");
	}
	
	
	/**
	 * 判断此字符串是否是一个电子邮箱
	 * @param str
	 * @return
	 */
	public static boolean isEmail(String str){
		return EmptyUtils.isEmpty(str) ? false : str.matches("^[a-zA-Z0-9][a-zA-Z0-9_\\-\\.]{0,19}@(?:[a-zA-Z0-9\\-]+\\.)+[a-zA-Z]+$");
	}
	
	/**
	 * 判断字符串是否是一个手机号
	 * @param str
	 * @return
	 */
	public static boolean isMobileNum(String str){
		return EmptyUtils.isEmpty(str) ? false : str.matches("^1[0-9]{10}$");
	}
	
	
	/**
	 * 判断是否是一个身份证号
	 * @param str
	 * @return
	 */
	public static boolean isIdCardNum(String str){
		if(EmptyUtils.isEmpty(str) || (str.length() != 15 && str.length() != 18)){
			return false;
		}
		if(str.length() == 15){
			return str.matches("^[1-9]\\d{7}((0[1-9])||(1[0-2]))((0[1-9])||(1\\d)||(2\\d)||(3[0-1]))\\d{3}$");
		}else{
			return str.toUpperCase().matches("^[1-9]\\d{5}[1-9]\\d{3}((0[1-9])||(1[0-2]))((0[1-9])||(1\\d)||(2\\d)||(3[0-1]))\\d{3}([0-9]||X)$");
		}
	}
	
	
	/**
	 * 拼接字符串
	 * @param strs 字符串数组
	 * @param separator 拼接符(默认值为,)
	 * @return
	 */
	public static String join(String[] strs, String separator){
		StringBuilder sb = new StringBuilder();
		if(separator == null){
			separator = ",";
		}
		for(int i=0, len=strs.length-1; i < len; i++){
			sb.append(strs[i]+separator);
		}
		sb.append(strs[strs.length-1]);
		return sb.toString();
	}
	
	/**
	 * 以逗号拼接字符串
	 * @param strs 字符串数组
	 * @return
	 */
	public static String join(String[] strs){
		return join(strs,null);
	}
	
	/**
	 * 拼接字符串
	 * @param strs 字符串集合
	 * @param separator 拼接符
	 * @return
	 */
	public static String join(Collection<String> strs, String separator){
		return StringUtil.join(strs.toArray(new String[strs.size()]), separator);
	}
	
	/**
	 * 以逗号拼接字符串
	 * @param strs 字符串集合
	 * @return
	 */
	public static String join(Collection<String> strs){
		return join(strs,null);
	}
	
	
	/**
	 * 将字符串填充或减少至目标长度
	 * @param str 需要被操作的字符串
	 * @param len 目标长度,不能小于0,小于0将返回null
	 * @param direction 操作的方向,是在字符串前面操作还是字符串后面操作,取常量
	 * @param operator 如果长度不够,需要的填充符,默认为0
	 * @return
	 */
	public static String replenish(String str, int len,String direction,Character operator){
		String result = null;
		if(str != null && len >= 0 && Tools.equals(direction, BEFORE,AFTER)){
			int size = str.length();
			if(size != len){
				if(EmptyUtils.isEmpty(operator)){
					operator = '0';
				}
				if(len == 0){
					result = "";
				}else{
					if(size < len){
						//填充
						int num = len - size;
						StringBuilder sb = new StringBuilder();
						for(int i=0; i<num; i++){
							sb.append(operator);
						}
						if(Tools.equals(direction, BEFORE)){
							result = sb.toString()+str;
						}else{
							result = str + sb.toString();
						}
					}else{
						//减少
						if(Tools.equals(direction, BEFORE)){
							result = str.substring(str.length() - len);
						}else{
							result = str.substring(0,len);
						}
						
					}
				}
			}else{
				result = str; 
			}
		}
		return result;
	}
	
	
	/**
	 * 删除小数后面的0或者后面的.
	 * @param str
	 * @return
	 */
	public static String deleteDecimalAfterZero(String str){
		return StringUtil.isDecimal(str) ? str.replaceAll("(\\.?0+)$","") : str;
	}
	
	/**
	 * 将double转换为字符串(小数位不能超过5位)
	 * @param d
	 * @return
	 */
	public static String toString(Double d){
		String result = null;
		if(EmptyUtils.isNotEmpty(d)){
			result = StringUtil.deleteDecimalAfterZero(PreciseArithmeticUtil.round(d, -1));
		}
		return result;
	}
	
	/**
	 * 将float转换为字符串(小数位不能超过5位)
	 * @param f
	 * @return
	 */
	public static String toString(Float f){
		String result = null;
		if(EmptyUtils.isNotEmpty(f)){
			result = StringUtil.deleteDecimalAfterZero(PreciseArithmeticUtil.round(f, -1));
		}
		return result;
	}
	
	/**
	 * 替换回车并将多个空格替换为一个空格
	 * @param text
	 * @return
	 */
	public static String replaceEnter(String text){
		String result = null;
		if(EmptyUtils.isNotEmpty(text)){
			result = text.replaceAll("[\\t\\n\\r]", " ").replaceAll(" +", " ");
		}else{
			result = text;
		}
		return result;
	}
	
	
	
	/**
	 * 将驼峰风格替换为下划线风格
	 * @param str
	 * @return
	 */
    public static String camelhumpToUnderline(String str) {
    	String result = null;
    	if(EmptyUtils.isNotEmpty(str)){
    		final int size;
            final char[] chars;
            final StringBuilder sb = new StringBuilder((size = (chars = str.toCharArray()).length) * 3 / 2 + 1);
            char c;
            for (int i = 0; i < size; i++) {
                c = chars[i];
                if (isUppercaseAlpha(c)) {
                    sb.append('_').append(toLowerAscii(c));
                } else {
                    sb.append(c);
                }
            }
            result = sb.charAt(0) == '_' ? sb.substring(1) : sb.toString();
    	}else{
    		result = str;
    	}
        return result;
    }

    /**
     * 将下划线风格替换为驼峰风格
     * @param str
     * @return
     */
    public static String underlineToCamelhump(String str,boolean firstLetterLowerCase) {
    	String result = null;
    	if(EmptyUtils.isNotEmpty(str)){
    		Matcher matcher = FIRST_LETTER_PATTERN.matcher(str);
	        StringBuilder builder = new StringBuilder(str);
	        for (int i = 0; matcher.find(); i++) {
	            builder.replace(matcher.start() - i, matcher.end() - i, matcher.group().substring(1).toUpperCase());
	        }
	        if (firstLetterLowerCase && Character.isUpperCase(builder.charAt(0))) {
	            builder.replace(0, 1, String.valueOf(Character.toLowerCase(builder.charAt(0))));
	        }else if(!firstLetterLowerCase && Character.isLowerCase(builder.charAt(0))){
	        	builder.replace(0, 1, String.valueOf(Character.toUpperCase(builder.charAt(0))));
	        }
	        result = builder.toString();
    	}else{
    		result = str;
    	}
        return result;
    }
    
    /**
     * 将下划线风格替换为驼峰风格,首字母小写
     * @param str
     * @return
     */
    public static String underlineToCamelhump(String str) {
    	return underlineToCamelhump(str, true);
    }

    /**
     * 是否是大写字母
     * @param c
     * @return
     */
    public static boolean isUppercaseAlpha(char c) {
        return (c >= 'A') && (c <= 'Z');
    }

    /**
     * 是否是小写字母
     * @param c
     * @return
     */
    public static boolean isLowercaseAlpha(char c) {
        return (c >= 'a') && (c <= 'z');
    }

    
    /**
     * 将字母转换为大写
     * @param c
     * @return
     */
    public static char toUpperAscii(char c) {
        if (isLowercaseAlpha(c)) {
            c -= (char) 0x20;
        }
        return c;
    }

    /**
     * 将字母转换为小写
     * @param c
     * @return
     */
    public static char toLowerAscii(char c) {
        if (isUppercaseAlpha(c)) {
            c += (char) 0x20;
        }
        return c;
    }
    
    
    
    /**
     * 删除字符串中指定的前缀
     * @param str 字符串
     * @param prefix 前缀
     * @return
     */
    public static String deletePrefix(String str,String prefix){
    	String result = str;
    	if(EmptyUtils.isNotEmptys(str, prefix)){
    		if(str.startsWith(prefix)){
    			result = str.substring(prefix.length(), str.length());
    		}
    	}
    	return result;
    }
    
    
    /**
     * 删除字符串中指定的后缀
     * @param str 字符串
     * @param suffix 后缀
     * @return
     */
    public static String deleteSuffix(String str,String suffix){
    	String result = str;
    	if(EmptyUtils.isNotEmptys(str, suffix)){
    		if(str.endsWith(suffix)){
    			result = str.substring(0, str.length()-suffix.length());
    		}
    	}
    	return result;
    }
    
    
    /**
     * 删除字符串中指定的前缀和后缀
     * @param str
     * @param prefixSuffix
     * @return
     */
    public static String deletePrefixSuffix(String str,String prefixSuffix){
    	String result = str;
    	if(EmptyUtils.isNotEmptys(str,prefixSuffix)){
    		result = deletePrefix(result, prefixSuffix);
    		result = deleteSuffix(result, prefixSuffix);
    	}
    	return result;
    }
    
    /**
     * 给字符串添加指定的前缀
     * @param str 字符串
     * @param prefix 前缀
     * @return
     */
    public static String addPrefix(String str,String prefix){
    	String result = str;
    	if(EmptyUtils.isNotEmptys(str, prefix)){
    		if(!str.startsWith(prefix)){
    			result = prefix + str;
    		}
    	}
    	return result;
    }
    
    
    /**
     * 给字符串添加指定的后缀
     * @param str 字符串
     * @param suffix 后缀
     * @return
     */
    public static String addSuffix(String str,String suffix){
    	String result = str;
    	if(EmptyUtils.isNotEmptys(str, suffix)){
    		if(!str.endsWith(suffix)){
    			result = str + suffix;
    		}
    	}
    	return result;
    }
    
    /**
     * 给字符串添加指定的前缀和后缀
     * @param str
     * @param prefixSuffix
     * @return
     */
    public static String addPrefixSuffix(String str,String prefixSuffix){
    	String result = str;
    	if(EmptyUtils.isNotEmptys(str,prefixSuffix)){
    		result =addPrefix(str, prefixSuffix);
    		result = addSuffix(result, prefixSuffix);
    	}
    	return result;
    }

    /**
     * @describe: 将一个对象toString()，如果对象为null,返回一个空字符串
     * @author: hcl  
     * @date: 2018/7/4 11:12
     * @param: [obj]  
     * @return java.lang.String  
     */
	public static String getObjectStr(Object obj){
		return obj == null ? "" : obj.toString();
	}

}
